package com.dxg.msns.user.controller;

import com.dxg.msns.common.pojo.PageResult;
import com.dxg.msns.common.util.CodecUtils;
import com.dxg.msns.common.util.Result;
import com.dxg.msns.user.enums.UserRoleEnum;
import com.dxg.msns.user.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import com.dxg.msns.user.pojo.User;
import com.dxg.msns.user.pojo.UserLoginVO;

import javax.validation.Valid;
import java.net.URLDecoder;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/api/user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 分页查询所有用户
     * 
     * @param key
     * @param page
     * @param rows
     * @param sortBy
     * @param desc
     * @return
     */
    @GetMapping("/page")
    public Result<PageResult<User>> queryUsersByPage(
            @RequestParam(value = "key", required = false) String key,
            @RequestParam(value = "page", defaultValue = "1") Integer page,
            @RequestParam(value = "rows", defaultValue = "5") Integer rows,
            @RequestParam(value = "sortBy", required = false) String sortBy[],
            @RequestParam(value = "desc", required = false) Boolean desc[],
            @RequestParam(value = "uids", required = false) String[] uids) {
        PageResult<User> result = userService.queryUsersByPage(key, page, rows, sortBy, desc, uids);
        return Result.success(result);
    }

    /**
     * 新增用户
     * 
     * @param user
     * @return
     */
    @PostMapping("/adduser")
    public ResponseEntity<String> saveUser(@RequestBody User user) {
        // 在插入前查询是否存在该用户名
        boolean hadUser = userService.findUserByName(user);
        if (!hadUser) {
            return new ResponseEntity("已存在该用户！", HttpStatus.BAD_REQUEST);
        } else {
            userService.saveUser(user);
            return ResponseEntity.status(HttpStatus.CREATED).build();
        }

    }

    /**
     * 修改个人信息
     * 
     * @param user
     * @return
     */
    @PutMapping
    public ResponseEntity<Void> updateUser(@RequestBody User user) {
        userService.updateUser(user);
        return ResponseEntity.status(HttpStatus.CREATED).build();
    }

    /**
     * 删除个人信息
     * 
     * @param id
     * @return
     */
    @PostMapping("/deleteUser")
    public Result<String> deleteUser(@RequestParam("id") Integer id) {
        userService.deleteUser(id);
        return Result.success("删除成功");
    }

    /**
     * 查询用户名和邮箱手机是否可用（type:1验证用户名，2验证手机号，3验证邮箱）
     * 
     * @param data
     * @param type
     * @return
     */
    @GetMapping("/check/{data}/{type}")
    public ResponseEntity<Boolean> checkUserData(@PathVariable("data") String data,
            @PathVariable("type") Integer type) {
        Boolean check = userService.checkUserData(data, type);
        if (check == null) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
        }
        return ResponseEntity.ok(check);
    }

    /**
     * 根据id查找用户头像和昵称
     * 
     * @param uid
     * @return
     */
    @GetMapping("/queryNameAvatarById")
    public ResponseEntity<User> queryNameAvatarById(@RequestParam("uid") String uid) {
        User user = userService.queryNameAvatarById(uid);
        if (user == null) {
            return ResponseEntity.notFound().build();
        }
        System.out.println("user:::" + user);
        return ResponseEntity.ok(user);
    }

    /**
     * 发送验证码
     * 
     * @param email
     * @return
     */
    @PostMapping("/code")
    public ResponseEntity<Void> sendVerifyCode(@RequestBody String email) {
        if (StringUtils.isEmpty(email)) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
        String decode = URLDecoder.decode(email);
        email = decode.substring(0, decode.indexOf("="));
        // System.out.println(email);
        Boolean boo = userService.sendVerifyCode(email);
        if (!boo) {
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
        return new ResponseEntity<>(HttpStatus.CREATED);
    }

    /**
     * 注册
     * 
     * @param user
     * @param code
     * @return
     */
    @PostMapping("/register")
    public ResponseEntity<Void> register(@Valid @RequestBody User user, @RequestParam("code") String code) {
        // System.out.println("用户："+user);
        // System.out.println("code:::"+code);
        Map<String, Object> map = userService.register(user, code);
        Boolean boo = (Boolean) map.get("boo");
        if (!boo) {
            return new ResponseEntity(map.get("err"), HttpStatus.INTERNAL_SERVER_ERROR);
        }
        return new ResponseEntity<>(HttpStatus.CREATED);
    }

    /**
     * 简单注册接口，只需要用户名和密码
     * 
     * @param uname
     * @param upassword
     * @return
     */
    @PostMapping("/registerSimple")
    public Result<String> registerSimple(@RequestParam("uname") String uname,
            @RequestParam("upassword") String upassword) {
        try {
            // 检查用户名是否为空
            if (StringUtils.isEmpty(uname) || StringUtils.isEmpty(upassword)) {
                return Result.error("用户名和密码不能为空");
            }

            // 检查用户名是否已存在
            Boolean isAvailable = userService.checkUserData(uname, 1);
            if (!isAvailable) {
                return Result.error("用户名已存在");
            }

            // 创建用户对象
            User user = new User();
            user.setUname(uname);
            user.setUpassword(upassword);

            // 设置用户状态：1-正常，0-禁用
            user.setStatus("1");

            // 设置用户角色：所有新注册用户默认为普通用户
            user.setUserRole(UserRoleEnum.NORMAL_USER);

            // 调用保存用户方法（会自动进行MD5加密）
            userService.saveUser(user);

            return Result.success("注册成功");

        } catch (Exception e) {
            System.err.println("注册异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("注册失败：" + e.getMessage());
        }
    }

    /**
     * 登录接口 - 供Feign客户端调用（返回User对象）
     * 
     * @param uname     用户名
     * @param upassword 密码
     * @return User对象，供auth服务使用
     */
    @GetMapping("/login")
    public User login(@RequestParam("uname") String uname,
            @RequestParam("upassword") String upassword) {
        try {
            // 用户认证
            User user = this.userService.queryUser(uname, upassword);
            System.out.println("Feign登录调用 - 用户: " + user);
            return user; // 直接返回User对象，null表示登录失败
        } catch (Exception e) {
            System.err.println("Feign登录异常：" + e.getMessage());
            e.printStackTrace();
            return null; // 返回null表示登录失败
        }
    }

    /**
     * 登录接口 - 直接前端调用（返回UserLoginVO）
     * 
     * @param uname     用户名
     * @param upassword 密码
     * @return UserLoginVO包含uid和token
     */
    @PostMapping("/loginWithToken")
    public Result<UserLoginVO> loginWithToken(@RequestParam("uname") String uname,
            @RequestParam("upassword") String upassword) {
        try {
            // 参数验证
            if (StringUtils.isEmpty(uname) || StringUtils.isEmpty(upassword)) {
                return Result.error("用户名和密码不能为空");
            }

            // 用户认证
            User user = this.userService.queryUser(uname, upassword);
            System.out.println("登录用户: " + user);

            if (user == null) {
                return Result.error("用户名或密码错误");
            }

            // 生成令牌（简单示例，实际项目中可以使用JWT）
            String token = generateToken(user);

            // 创建返回的VO对象
            UserLoginVO loginVO = new UserLoginVO(user, token);

            return Result.success("登录成功", loginVO);

        } catch (Exception e) {
            System.err.println("登录异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("登录失败：" + e.getMessage());
        }
    }

    /**
     * 生成用户令牌（简单实现，实际项目中建议使用JWT）
     * 
     * @param user 用户信息
     * @return 令牌字符串
     */
    private String generateToken(User user) {
        // 简单的token生成：用户uid + 当前时间戳 + 随机数的MD5
        String tokenSource = user.getUid() + System.currentTimeMillis() + Math.random();
        return CodecUtils.md5Hex(tokenSource, "msns_token_salt");
    }

    /**
     * 用户退出登录
     * 
     * @param uid 用户UID
     * @return
     */
    @PostMapping("/logout")
    public Result<String> logout(@RequestParam(value = "uid", required = false) String uid) {
        try {
            // 可以在这里记录退出日志或清理服务端会话信息
            if (!StringUtils.isEmpty(uid)) {
                System.out.println("用户 " + uid + " 已退出登录");
            }
            return Result.success("退出登录成功");
        } catch (Exception e) {
            System.err.println("退出登录异常：" + e.getMessage());
            return Result.error("退出登录失败");
        }
    }

    /**
     * 根据id查询用户
     * 
     * @param id
     * @return
     */
    @GetMapping("/queryById/{id}")
    public ResponseEntity<User> queryById(@PathVariable("id") Integer id) {
        User user = userService.queryById(id);
        System.out.println(user);
        if (user == null) {
            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
        }
        return ResponseEntity.ok(user);
    }

    /**
     * 根据uid修改密码
     * 
     * @param uid         用户UID
     * @param newPassword 新密码
     * @return
     */
    @PutMapping("/changePwdByUid")
    public Result<String> changePwdByUid(@RequestParam("uid") String uid,
            @RequestParam("newPassword") String newPassword) {
        try {
            // 参数验证
            if (StringUtils.isEmpty(uid) || StringUtils.isEmpty(newPassword)) {
                return Result.error("用户UID和新密码不能为空");
            }

            // 检查用户是否存在
            User user = userService.queryByUid(uid);
            if (user == null) {
                return Result.error("用户不存在");
            }

            // 修改密码（Service层会自动进行MD5加密）
            userService.changePwdByUid(uid, newPassword);

            return Result.success("密码修改成功");

        } catch (Exception e) {
            System.err.println("修改密码异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("密码修改失败：" + e.getMessage());
        }
    }

    /**
     * 根据uid修改头像
     * 
     * @param uid       用户UID
     * @param avatarUrl 头像URL
     * @return
     */
    @PutMapping("/changeAvatarByUid")
    public Result<String> changeAvatarByUid(@RequestParam("uid") String uid,
            @RequestParam("avatarUrl") String avatarUrl) {
        try {
            // 参数验证
            if (StringUtils.isEmpty(uid) || StringUtils.isEmpty(avatarUrl)) {
                return Result.error("用户UID和头像URL不能为空");
            }

            // 检查用户是否存在
            User user = userService.queryByUid(uid);
            if (user == null) {
                return Result.error("用户不存在");
            }

            System.out.println("Controller changeAvatarByUid called with uid: " + uid + ", avatarUrl: " + avatarUrl);
            userService.changeAvatarByUid(uid, avatarUrl);
            System.out.println("Controller changeAvatarByUid completed successfully");

            return Result.success("头像修改成功");
        } catch (Exception e) {
            System.err.println("Error in Controller changeAvatarByUid: " + e.getMessage());
            e.printStackTrace();
            return Result.error("修改头像失败: " + e.getMessage());
        }
    }

    /**
     * 根据uid修改昵称
     * 
     * @param uid   用户UID
     * @param uname 新昵称
     * @return
     */
    @PutMapping("/changeNicknameByUid")
    public Result<String> changeNicknameByUid(@RequestParam("uid") String uid,
            @RequestParam("uname") String uname) {
        try {
            // 参数验证
            if (StringUtils.isEmpty(uid) || StringUtils.isEmpty(uname)) {
                return Result.error("用户UID和昵称不能为空");
            }

            // 昵称长度验证
            if (uname.length() < 2 || uname.length() > 20) {
                return Result.error("昵称长度必须在2-20个字符之间");
            }

            // 检查用户是否存在
            User user = userService.queryByUid(uid);
            if (user == null) {
                return Result.error("用户不存在");
            }

            // 检查昵称是否已被其他用户使用
            Boolean isAvailable = userService.checkUserData(uname, 1);
            if (!isAvailable) {
                // 如果昵称已存在，但是是当前用户的昵称，则允许修改
                if (!uname.equals(user.getUname())) {
                    return Result.error("昵称已被其他用户使用");
                }
            }

            // 修改昵称
            userService.changeNicknameByUid(uid, uname);

            return Result.success("昵称修改成功");

        } catch (Exception e) {
            System.err.println("修改昵称异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("昵称修改失败：" + e.getMessage());
        }
    }

    /**
     * 根据uid修改用户角色
     * 
     * @param uid      用户UID
     * @param roleCode 角色代码（0-普通用户，1-音乐人，-1-音乐人申请中）
     * @return
     */
    @PutMapping("/changeRoleByUid")
    public Result<String> changeRoleByUid(@RequestParam("uid") String uid,
            @RequestParam("roleCode") Integer roleCode) {
        try {
            // 参数验证
            if (StringUtils.isEmpty(uid) || roleCode == null) {
                return Result.error("用户UID和角色代码不能为空");
            }

            // 验证角色代码是否有效
            if (!UserRoleEnum.isValidCode(roleCode)) {
                return Result.error("无效的角色代码");
            }

            // 检查用户是否存在
            User user = userService.queryByUid(uid);
            if (user == null) {
                return Result.error("用户不存在");
            }

            // 修改用户角色
            userService.changeRoleByUid(uid, roleCode);

            UserRoleEnum roleEnum = UserRoleEnum.getByCode(roleCode);
            return Result.success("用户角色已修改为：" + roleEnum.getDescription());

        } catch (Exception e) {
            System.err.println("修改用户角色异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("修改用户角色失败：" + e.getMessage());
        }
    }

    /**
     * 修改个人信息
     */
    @PostMapping("/updateUserInfo")
    public Result<String> updateUserInfo(@RequestBody User user) {
        try {
            // 调用 Service 层方法更新用户信息
            System.out.println(user);
            userService.updateUserInfo(user);

            // 返回成功响应
            return Result.success("修改成功");
        } catch (Exception e) {
            // 处理异常，返回失败响应
            return Result.error("修改失败" + e.getMessage());
        }

    }

    /**
     * 申请成为音乐人
     * 
     * @param userId 用户ID
     * @return 申请结果
     */
    @PostMapping("/applyForMusician")
    public Result<String> applyForMusician(@RequestParam("userId") String userId) {
        try {
            // 参数验证
            if (StringUtils.isEmpty(userId)) {
                return Result.error("用户ID不能为空");
            }

            // 检查用户是否存在
            User user = userService.queryByUid(userId);
            if (user == null) {
                return Result.error("用户不存在");
            }

            // 检查用户当前角色状态
            UserRoleEnum currentRole = user.getUserRole();
            if (currentRole == UserRoleEnum.SINGER) {
                return Result.error("您已经是音乐人，无需重复申请");
            }

            if (currentRole == UserRoleEnum.SINGER_APPLYING) {
                return Result.error("您的音乐人申请正在审核中，请耐心等待");
            }

            // 将用户角色设置为申请中状态（-1）
            userService.changeRoleByUid(userId, UserRoleEnum.SINGER_APPLYING.getCode());

            return Result.success("音乐人申请提交成功，请等待管理员审核");

        } catch (Exception e) {
            System.err.println("申请成为音乐人异常：" + e.getMessage());
            e.printStackTrace();
            return Result.error("申请失败：" + e.getMessage());
        }
    }

    @GetMapping("/testVisit")
    public Result testVisit() {
        System.out.println("测试访问业务");
        return Result.success();
    }

    @GetMapping("/queryUsersByName")
    public List<User> queryUsersByName(@RequestParam("uname") String uname) {
        List<User> userList = userService.queryUsersByName(uname);
        return userList;
    }

}
